﻿using GalaSoft.MvvmLight;
using SGTLightAccent.Web.Services;
using System.Collections.ObjectModel;
using SGTLightAccent.Web.Models;
using System.ServiceModel.DomainServices.Client;
using System;
using GalaSoft.MvvmLight.Command;
using SGTLightAccent.LoginUI;
using System.Windows;
using SGTLightAccent.Views;
using SGTLightAccent.Models;
using GalaSoft.MvvmLight.Messaging;
using SGTLightAccent.Web;
using System.ComponentModel.DataAnnotations;



namespace SGTLightAccent.ViewModel
{
    /// <summary>
    /// This class contains properties that a View can data bind to.
    /// <para>
    /// Use the <strong>mvvminpc</strong> snippet to add bindable properties to this ViewModel.
    /// </para>
    /// <para>
    /// You can also use Blend to data bind with the tool's support.
    /// </para>
    /// <para>
    /// See http://www.galasoft.ch/mvvm/getstarted
    /// </para>
    /// </summary>
    public class MainViewModel : ViewModelBase
    {
        /// <summary>
        /// Initializes a new instance of the MainViewModel class.
        /// </summary>
        /// 

        private static MainViewModel _instance = null;
        
        private EntitySet<Barco> _barcos;
        private EntitySet<Carga> _cargas;
        private EntitySet<Mercaderia> _productos;
        private EntitySet<Proveedor> _clientes;
        private Proveedor _clienteSeleccionado;
        private Proveedor _clienteNuevo;
        private Barco _barcoSeleccionado;
        private Barco _barcoNuevo;
        private Mercaderia _productoSeleccionado;
        private Mercaderia _productoNuevo;
        private Carga _cargaSeleccionada;
        private Carga _cargaNueva;
        private DateTime _filtroFechaIni;
        private DateTime _filtroFechaFin;
        private string _filtroBarco;
        private string _filtroProducto;
        private RegistrationData _registrationData; //Creacion de usuarios
        private UserRegistrationContext _userRegistrationContext;
        private Proveedor _clienteCarga;
        private bool _habilitarAcceso;
        private bool _reiniciarPass;
        private bool _reiniciarPassEnable;
        private bool _crearNuevoUsuario = true;
        

       
        public RelayCommand BotonGuardarBarco { get; private set; }
        public RelayCommand BotonNuevoBarco { get; private set; }
        public RelayCommand BotonBuscarBarco { get; private set; }
        public RelayCommand BotonActualizarBarco { get; private set; }
        public RelayCommand BotonGuardarProducto { get; private set; }
        public RelayCommand BotonNuevoProducto { get; private set; }
        public RelayCommand BotonActualizarProducto { get; private set; }
        public RelayCommand BotonEliminarProducto { get; private set; }
        public RelayCommand BotonBuscarProducto { get; private set; }
        public RelayCommand BotonBuscarCarga { get; private set; }
        public RelayCommand BotonNuevaCarga { get; private set; }
        public RelayCommand BotonGuardarCarga { get; private set; }
        public RelayCommand BotonActualizarCarga { get; private set; }
        public RelayCommand BotonEliminarDescarga { get; private set; }
        public RelayCommand BotonIncrementarBodegas { get; private set; }
        public RelayCommand BotonBuscarClientes { get; private set; }
        public RelayCommand BotonNuevoCliente { get; private set; }
        public RelayCommand BotonActualizarCliente { get; private set; }
        public RelayCommand BotonGuardarCliente { get; private set; }
        private bool _mostrar;
        private bool _prodTxtVisible;
        private bool _filtroChkBarco;
        private bool _filtroChkProducto;
        private bool _filtroChkFchIni;
        private bool _filtroChkFchFin;
        private bool _estaCargando;
        private SGTDomainContext contexto;
        private int _cantBodegas = 0;
        

        #region Fields

        public bool ReiniciarPassEnable
        {
            get { return _reiniciarPassEnable; }
            set
            {

                _reiniciarPassEnable = value;
                RaisePropertyChanged("ReiniciarPassEnable");


            }
        }

        public bool ReiniciarPass
        {
            get { return _reiniciarPass; }
            set
            {

                _reiniciarPass = value;
                RaisePropertyChanged("ReiniciarPass");


            }
        }

        public bool HabilitarAcceso
        {
            get { return _habilitarAcceso; }
            set
            {

                _habilitarAcceso = value;
                RaisePropertyChanged("HabilitarAcceso");


            }
        }

        public Proveedor ClienteCarga
        {
            get { return _clienteCarga; }
            set
            {

                _clienteCarga = value;
                RaisePropertyChanged("ClienteCarga");


            }
        }

        public RegistrationData registrationData
        {
            get { return _registrationData; }
            set
            {

                _registrationData = value;
                RaisePropertyChanged("registrationData");


            }
        }

        public int CantBodegas
        {
            get { return _cantBodegas; }
            set
            {

                _cantBodegas = value;
                RaisePropertyChanged("CantBodegas");


            }
        }


        public bool EstaCargando
        {
            get { return _estaCargando; }
            set
            {

                _estaCargando = value;
                RaisePropertyChanged("EstaCargando");


            }
        }

        public bool FiltroChkBarco
        {
            get { return _filtroChkBarco; }
            set
            {

                _filtroChkBarco = value;
                RaisePropertyChanged("FiltroChkBarco");


            }
        }
        public bool FiltroChkProducto
        {
            get { return _filtroChkProducto; }
            set
            {

                _filtroChkProducto = value;
                RaisePropertyChanged("FiltroChkProducto");


            }
        }

        public bool FiltroChkFchIni
        {
            get { return _filtroChkFchIni; }
            set
            {

                _filtroChkFchIni = value;
                RaisePropertyChanged("FiltroChkFchIni");


            }
        }

        public bool FiltroChkFchFin
        {
            get { return _filtroChkFchFin; }
            set
            {

                _filtroChkFchFin = value;
                RaisePropertyChanged("FiltroChkFchFin");


            }
        }


        public DateTime FiltroFechaIni
        {
            get { return _filtroFechaIni; }
            set
            {
                _filtroFechaIni = value;
                RaisePropertyChanged("FiltroFechaIni");


            }
        }

        public DateTime FiltroFechaFin
        {
            get { return _filtroFechaFin; }
            set
            {
                _filtroFechaFin = value;
                RaisePropertyChanged("FiltroFechaFin");


            }
        }

        public string FiltroBarco
        {
            get { return _filtroBarco; }
            set
            {
                _filtroBarco = value;
                RaisePropertyChanged("FiltroBarco");


            }
        }


        public string FiltroProducto
        {
            get { return _filtroProducto; }
            set
            {          
                _filtroProducto = value;
                RaisePropertyChanged("FiltroProducto");


            }
        }


  

        public bool ProdTxtVisible
        {
            get { return _prodTxtVisible; }
            set
            {

                _prodTxtVisible = value;
                RaisePropertyChanged("ProdTxtVisible");


            }
        }

        public bool Mostrar
        {
            get { return _mostrar; }
            set
            {
                
                _mostrar = value;
                RaisePropertyChanged("Mostrar");


            }
        }

        public Proveedor ClienteSeleccionado
        {
            get { return _clienteSeleccionado; }
            set
            {

                _clienteSeleccionado = value;
                RaisePropertyChanged("ClienteSeleccionado");


            }
        }

        public Proveedor ClienteNuevo
        {
            get { return _clienteNuevo; }
            set
            {

                _clienteNuevo = value;
                RaisePropertyChanged("ClienteNuevo");


            }
        }

        public Carga CargaNueva
        {
            get { return _cargaNueva; }
            set
            {

                _cargaNueva = value;
                RaisePropertyChanged("CargaNueva");


            }
        }

        public Carga CargaSeleccionada
        {
            get { return _cargaSeleccionada; }
            set
            {
                if (value != null)
                {
                    _cargaSeleccionada = value;
                    RaisePropertyChanged("CargaSeleccionada");
                }


            }
        }

        public Barco BarcoNuevo
        {
            get { return _barcoNuevo; }
            set
            {

                _barcoNuevo = value;
                RaisePropertyChanged("BarcoNuevo");


            }
        }

        public Barco BarcoSeleccionado
        {
            get { return _barcoSeleccionado; }
            set
            {

                _barcoSeleccionado = value;
                RaisePropertyChanged("BarcoSeleccionado");


            }
        }
        public Mercaderia ProductoSeleccionado
        {
            get { return _productoSeleccionado; }
            set
            {
                   _productoSeleccionado = value;
                    RaisePropertyChanged("ProductoSeleccionado");
                

                


            }
        }

        public Mercaderia ProductoNuevo
        {
            get { return _productoNuevo; }
            set
            {

                _productoNuevo = value;
                RaisePropertyChanged("ProductoNuevo");
              


            }
        }

        #endregion
        #region Entidades

        public EntitySet<Proveedor> Clientes
        {
            get { return _clientes; }
            set
            {

                _clientes = value;
                RaisePropertyChanged("Clientes");


            }
        }

        public EntitySet<Carga> Cargas
        {
            get { return _cargas; }
            set
            {

                _cargas = value;
                RaisePropertyChanged("Cargas");


            }
        }


        public EntitySet<Mercaderia> Productos
        {
            get { return _productos; }
            set
            {

                _productos = value;
                RaisePropertyChanged("Productos");


            }
        }

        public EntitySet<Barco> Barcos
        {
            get { return _barcos; }
            set
            {

                _barcos = value;
                RaisePropertyChanged("Barcos");


            }
        }


       
        #endregion

       

        public static MainViewModel getInstance()
        {
            if (_instance == null)
                _instance = new MainViewModel();
            return _instance;
        }

        protected MainViewModel()
        {
            if (IsInDesignMode)
            {
                // Code runs in Blend --> create design time data.
            }
            else
            {
                Messenger.Default.Register<EnvioMensaje>(this, msg => procesarMensaje(msg));
               
                ProdTxtVisible = false;
              
                BotonGuardarBarco = new RelayCommand(guardarBarco);
                BotonNuevoBarco = new RelayCommand(nuevoBarco);
                BotonBuscarBarco = new RelayCommand(cargarBarcos);
                BotonActualizarBarco = new RelayCommand(actualizarBarco);
                BotonGuardarProducto = new RelayCommand(guardarProducto);
                BotonNuevoProducto = new RelayCommand(nuevoProducto);
                BotonActualizarProducto = new RelayCommand(actualizarProducto);
                BotonEliminarProducto = new RelayCommand(eliminarProducto);
                BotonBuscarCarga = new RelayCommand(buscarCarga);
                BotonNuevaCarga = new RelayCommand(nuevaCarga);
                BotonGuardarCarga = new RelayCommand(guardarCarga);
                BotonActualizarCarga = new RelayCommand(actualizarCarga);
                BotonEliminarDescarga = new RelayCommand(eliminarDescarga);
                BotonBuscarProducto = new RelayCommand(cargarProductos);
                BotonIncrementarBodegas = new RelayCommand(incrementarBodegas);
                BotonBuscarClientes = new RelayCommand(buscarClientes);
                BotonNuevoCliente = new RelayCommand(nuevoCliente);
                BotonActualizarCliente = new RelayCommand(actualizarCliente);
                

                contexto = new SGTDomainContext();
              
               
            }
           
        }

        private void eliminarProducto()
        {
            if (ProductoSeleccionado != null)
            {
                
                string pNombre = ProductoSeleccionado.Nombre;
              
                    MessageBoxResult s = MessageBox.Show("Se eliminará el producto " + pNombre + ". ¿Esta seguro?", "Cuidado", MessageBoxButton.OKCancel);
                    if (s == MessageBoxResult.OK)
                    {
                        contexto.Mercaderias.Remove(ProductoSeleccionado);

                        contexto.SubmitChanges(LoadOperation =>
                            {
                            
                                if (LoadOperation.HasError)
                                {
                                    if (LoadOperation.Error.Message.Contains("DELETE"))
                                    {
                                        Mensaje v = new Mensaje("No es posible eliminar.\nExisten descargas que utilizan este producto");
                                        v.Show();
                                    }
                                     cargarProductos();
                                     LoadOperation.MarkErrorAsHandled();
                                }
                                else
                                {
                                    Mensaje v = new Mensaje("Producto eliminado.");
                                    v.Show();
                                }
                                
                            }, null);
                      }
               
            }
        }

        private void eliminarDescarga()
        {
            if (CargaSeleccionada != null)
            {

                int idCarga = CargaSeleccionada.Id;

                MessageBoxResult s = MessageBox.Show("Se eliminará la carga  " + idCarga + " y sus remitos. ¿Esta seguro?", "Cuidado", MessageBoxButton.OKCancel);
                if (s == MessageBoxResult.OK)
                {
                    contexto.Cargas.Remove(CargaSeleccionada);

                    contexto.SubmitChanges(LoadOperation =>
                    {

                        if (LoadOperation.HasError)
                        {
                            //if (LoadOperation.Error.Message.Contains("DELETE"))
                            //{
                                Mensaje v = new Mensaje("Ocurrió un error en la operación.");
                                v.Show();
                            //}
                            buscarCarga();
                            LoadOperation.MarkErrorAsHandled();
                        }
                        else
                        {
                            Mensaje v = new Mensaje("Carga eliminada.");
                            v.Show();
                        }

                    }, null);
                }

            }
        }

        private void nuevoUsuario(string pass)
        {
            if (_crearNuevoUsuario)
            {
                registrationData.FriendlyName = ClienteNuevo.Nombre;

                registrationData.Answer = "Nada";
                registrationData.Question = "Nada";
                registrationData.Password = pass;
                registrationData.PasswordConfirmation = pass;
                registrationData.PasswordAccessor = () => pass;

                registrationData.CurrentOperation = _userRegistrationContext.CreateUser(
                      registrationData,
                      registrationData.Password,
                      RegistrationOperation_Completed, null);
            }
            else
                actualizarUsuario();
        }

        private void actualizarUsuario()
        {
            _userRegistrationContext.CambiarCorreo(registrationData.UserName, registrationData.Email);

        }
        private void cambiarContrasena(string pass)
        {
            _userRegistrationContext.CambiarCorreo(registrationData.UserName, registrationData.Email);
            _userRegistrationContext.CambiarPass(registrationData.UserName, pass);
        }

        private void guardarCliente()
        {
            if (ClienteNuevo.ProveedorID == 0)
                contexto.Proveedors.Add(ClienteNuevo);
            try
            {
                contexto.SubmitChanges(LoadOperation =>
                {
                    Mensaje v = new Mensaje("El cliente " + ClienteNuevo.Nombre + " fue guardado con éxito.");
                v.Show();
                 },null);
                
            }
            catch (Exception ex)
            {
                Mensaje v = new Mensaje(ex.Message);
                v.Show();
            }
        }

        private void RegistrationOperation_Completed(InvokeOperation<CreateUserStatus> operation)
        {
            if (!operation.IsCanceled)
            {
                if (operation.HasError)
                {
                    ErrorWindow.CreateNew(operation.Error);
                    operation.MarkErrorAsHandled();
                }
                else if (operation.Value == CreateUserStatus.Success)
                {
                    ClienteNuevo.Usuario_FK = registrationData.UserName;
                    guardarCliente();

                }
                else if (operation.Value == CreateUserStatus.DuplicateUserName)
                {
                    this.registrationData.ValidationErrors.Add(new ValidationResult(ErrorResources.CreateUserStatusDuplicateUserName, new string[] { "UserName" }));
                }
                else if (operation.Value == CreateUserStatus.DuplicateEmail)
                {
                    this.registrationData.ValidationErrors.Add(new ValidationResult(ErrorResources.CreateUserStatusDuplicateEmail, new string[] { "Email" }));
                }
                else
                {
                    ErrorWindow.CreateNew(ErrorResources.ErrorWindowGenericError);
                }
            }
        }

        

        private void buscarClientes()
        {
            if (Clientes != null)
                Clientes.Clear();
            contexto.Load<Proveedor>(contexto.GetProveedorQuery(), LoadOperation =>
            {
                Clientes = contexto.Proveedors;

            }, null);
        }

        private void incrementarBodegas()
        {
            
            CantBodegas++;
            Bodega b = new Bodega();
            b.Numero = CantBodegas;
            CargaNueva.Bodega.Add(b);
           
        }

        private void procesarMensaje(EnvioMensaje msg)
        {
           
            if (msg.texto.Equals("CantBodegas"))
            {
                calcularCargaToneladas();
            }
            if (msg.texto.Equals("CrearUsuario"))
            {
                nuevoUsuario((string)msg.tag);
            }
            if (msg.texto.Equals("CrearClienteSinUsuario"))
            {
                guardarCliente();
            }
            if (msg.texto.Equals("UpdateDatos"))
            {
                actualizarUsuario();
            }
            if (msg.texto.Equals("ResetPass"))
            {
                cambiarContrasena((string)msg.tag);
            }
            //actualizarProducto();
        }

        private void calcularCargaToneladas()
        {
            CargaNueva.Peso = 0;
            foreach (Bodega b in CargaNueva.Bodega)
            {
                if (b != null)
                    CargaNueva.Peso += b.Toneladas;
            }
        }

        

    

        private void cargarBarcos()
        {
            if (Barcos != null)
                Barcos.Clear();
            contexto.Load<Barco>(contexto.GetBarcoQuery(), LoadOperation =>
                {
                    Barcos = contexto.Barcos;
                   
                },null);
            

        }

        private void guardarBarco()
        {
            //actualizarProductoBarco(BarcoNuevo);
            
            if (BarcoNuevo.id == 0)
                contexto.Barcos.Add(BarcoNuevo);
            try
            {
                contexto.SubmitChanges();
                Mensaje v = new Mensaje("El barco " + BarcoNuevo.Nombre + " fue guardado con éxito.");
                v.Show();
            }
            catch (Exception ex)
            {
                Mensaje v = new Mensaje(ex.Message);
                v.Show();
            }

           
        }

       

        private void nuevoBarco()
        {
            BarcoNuevo = new Barco();
            CantBodegas = 0;
            NuevoBarcoWindow v = new NuevoBarcoWindow("Nuevo Barco");
            v.Show();
        }

        private void actualizarCliente()
        {
            /*_userRegistrationContext.Load<string>(_userRegistrationContext.obtenerCorreo(ClienteSeleccionado.Usuario_FK), LoadOperation =>
                 _userRegistrationContext.RegistrationDatas*/
            registrationData = new RegistrationData();
            _userRegistrationContext = new UserRegistrationContext();
         
            registrationData.UserName = ClienteSeleccionado.Usuario_FK;
            //_userRegistrationContext.CambiarPass("vnando", "l@polla");


            if (ClienteSeleccionado.Usuario_FK != null)
            {
                HabilitarAcceso = true;
                ReiniciarPass = false;
                ReiniciarPassEnable = true;
                _userRegistrationContext.getCorreo(ClienteSeleccionado.Usuario_FK, io => registrationData.Email = io.Value, null);
                registrationData.Password = "1234@ABC";
                registrationData.PasswordConfirmation = "1234@ABC";
                _crearNuevoUsuario = false;
            }
            else
            {
                HabilitarAcceso = false;
                ReiniciarPassEnable = false;
                ReiniciarPass = false;
                _crearNuevoUsuario = true;
            }
            ClienteNuevo = ClienteSeleccionado;
            NuevoClienteWindow v = new NuevoClienteWindow("Modificar Cliente");
            v.Show();

        }
        private void actualizarBarco()
        {
            BarcoNuevo = BarcoSeleccionado;
            
            /*contexto.Load<Bodega>(contexto.GetBodegaByBarcoQuery(BarcoNuevo.id), LoadOperation =>
                {
                    CantBodegas = BarcoNuevo.Bodega.Count;
                    
                }, null);
           */
            NuevoBarcoWindow v = new NuevoBarcoWindow("Modificar Barco");
            v.Show();
        }

        private void cargarProductos()
        {
            if (Productos != null)
                Productos.Clear();
            contexto.Load<Mercaderia>(contexto.GetMercaderiaQuery(),  LoadBehavior.RefreshCurrent,LoadOperation =>
                {

                    Productos = contexto.Mercaderias;
                },null);
            

        }

        private void nuevoCliente()
        {
            registrationData = new RegistrationData();
            _userRegistrationContext = new UserRegistrationContext();
            ClienteNuevo = new Proveedor();
            ReiniciarPass = false;
            ReiniciarPassEnable = false;
            
            
            NuevoClienteWindow v = new NuevoClienteWindow("Nuevo Cliente");
            v.Show();
        }

        private void nuevoProducto()
        {
            //ProductoSeleccionado = new Mercaderia();
            _productoNuevo = new Mercaderia();
            NuevoProductoWindow v = new NuevoProductoWindow("Nuevo producto");
            v.Show();
            
           

        }
        private void guardarProducto()
        {
            //ProductoSeleccionado.Nombre = ProductoSeleccionado.Nombre.ToUpper();
            if (_productoNuevo.MercaderiaID == 0)
            {
                contexto.Mercaderias.Add(_productoNuevo);
                try
                {
                    contexto.SubmitChanges();
                    Mensaje v = new Mensaje("El producto " + _productoNuevo.Nombre + " fue creado con éxito.");
                    v.Show();
                }
                catch (Exception ex)
                {
                    Mensaje v = new Mensaje(ex.Message);
                    v.Show();
                }
            }
            else
                actualizarProductoBD();
           
        }

        private void actualizarProducto()
        {
            ProductoNuevo = ProductoSeleccionado;
            NuevoProductoWindow v = new NuevoProductoWindow("Modificar producto");
            v.Show();
        }

        private void actualizarProductoBD()
        {
            
            try
            {
                contexto.SubmitChanges(LoadOperation =>
                    {
                        Mensaje v = new Mensaje("El producto " + ProductoSeleccionado.Nombre + " fue actualizado con éxito.");
                        v.Show();
                    
                    },null);
                    
               
            }
            catch (Exception ex)
            {
                Mensaje v = new Mensaje(ex.Message);
                v.Show();
            }
        }

        private void buscarCarga()
        {
            EstaCargando = true;
            cargarBarcos();
            cargarProductos();
            if (Cargas != null)
                Cargas.Clear();
            string nomBarco = null;
            string prod = null;
            DateTime ini = new DateTime(1900,1,1);
            DateTime fin = new DateTime(2100, 1, 1);
   
            if (FiltroChkBarco == true)
                nomBarco = FiltroBarco;
            if (FiltroChkProducto == true)
                prod = FiltroProducto.ToUpper();
            if (FiltroChkFchIni == true)
                ini = FiltroFechaIni;
            if (FiltroChkFchFin == true)
                fin = FiltroFechaFin;

            contexto.Load<Carga>(contexto.GetCargaFiltradaQuery(nomBarco, prod, ini, fin), LoadBehavior.RefreshCurrent, LoadOperation =>
                {
                    Cargas = contexto.Cargas;
                    
                    EstaCargando = false;
                },null);
            
        }

        private void nuevaCarga()
        {
            buscarClientes();
            cargarBarcos();
            CargaNueva = new Carga();
            contexto.Load<Proveedor>(contexto.GetProveedorQuery(), LoadBehavior.RefreshCurrent,false);
            NuevaCargaWindow v = new NuevaCargaWindow("Nueva carga");
            v.Show();
        }

        private void actualizarCarga()
        {
            cargarBarcos();
            
            contexto.Load<Proveedor>(contexto.GetProveedorQuery(), LoadBehavior.RefreshCurrent, callback =>
            {
                Clientes = contexto.Proveedors;
                CargaNueva = CargaSeleccionada;
                contexto.Load<Barco>(contexto.GetBarcoQuery(),LoadBehavior.RefreshCurrent,false);
                contexto.Load<Bodega>(contexto.GetBodegaByCargaQuery(CargaNueva.Id), LoadBehavior.RefreshCurrent, LoadOperation =>
                {
                    CantBodegas = CargaNueva.Bodega.Count;
                    BarcoSeleccionado = CargaNueva.Barco;

                }, null);
            }, false);
           
        
            NuevaCargaWindow v = new NuevaCargaWindow("Modificar carga");
            v.Show();
        }

        private void guardarCarga()
        {
            string mensaje = "Se actualizó la carga " + CargaNueva.Id;
            try
            {
                validarNuevaCarga();
                if (CargaNueva.Id == 0)
                {
                    contexto.Cargas.Add(CargaNueva);
                    mensaje = "Se ingresó una nueva entrada del barco " + CargaNueva.Barco.Nombre + " con éxito.";
                }
                EstaCargando = true;
                contexto.SubmitChanges(LoadOperation =>
                    {
                        Mensaje v = new Mensaje(mensaje);
                        v.Show();
                        buscarCarga();
                        EstaCargando = false;
                        
                    
                    },null);
               
            }
            catch (Exception ex)
            {
                Mensaje v = new Mensaje(ex.Message);
                v.Show();
            }
        }

        private void validarNuevaCarga()
        {
            if (CargaNueva == null)
                throw new Exception("Carga no inicializada.");
            if (CargaNueva.Barco == null)
                throw new Exception("Debe seleccionar un Barco.");
            if (CargaNueva.Bodega == null)
                throw new Exception("Debe crear al menos una Bodega.");
            if (CargaNueva.Fecha_Ingreso == null)
                throw new Exception("Debe ingresar la fecha de ingreso");
            if (CargaNueva.Fecha_Salida == null)
                throw new Exception("Debe ingresar la fecha de salida");
                  }



        ////public override void Cleanup()
        ////{
        ////    // Clean own resources if needed

        ////    base.Cleanup();
        ////}
    }
}